Amiga News 95

home *** CD-ROM | disk | FTP | other *** search

/ Amiga News 95 / Amiga News 95.iso / dpat / dpat06 / sad / note < prev next >

Wrap

Text File | 1989-08-23 | 39.5 KB | 1,125 lines

S A D version MS/DOS 1.1 SYSTEME AUTOMATIQUE de DEVELOPPEMENT (c) Eric Hilly AOUT/1991 ____________________________________________________________Présentation SAD par le couplage de 2 notions, un système expert et une méthode de conception de programmes, est le prototype d'un outil destiné à aider à la résolution des problèmes de tests et de maintenance de l'ensemble d'un programme. Dans la lignée de la programmation structurée il y a une technique peu connue, la PSP, qui aborde ces problèmes. (Programmation Sans Panne de la société AAF : Automatisme Avancé de France). Pour un programmeur pratiquant la programmation structurée, son apprentissage est simple. Quant au novice, elle constitue un excellent moyen d'aborder la programmation. SAD écrit en BASIC aborde certains des principes de la PSP, et va permettre de tester leurs utilités. * Pourquoi le BASIC ? - Simplicité de mise en oeuvre, grâce à l'interpréteur. - Simplicité de programmation du générateur de code source basic. Et puis SAD n'est qu'un simple test et n'a pas la prétention de résoudre des problèmes de professionnels. * Pourquoi une méthode de programmation et d'analyse? 2 chiffres : - 70% des programmeurs travaillent sur des logiciels existants. - Il existe un nombre incompréssible de 5 à 10 fautes par millier de lignes de code (cf.Le Monde Informatique 13 Juillet 1987). Donc 2 objectifs : - Accélerer la lecture et la modification des programmes par une standardisation des règles d'écritures du code. - Réduire les erreurs par une bonne conception logique. Cela tient en 2 mots: maintenance et test. Maintenance: Que vous soyez seul ou en équipe, re-lire un code en vue d'une amélioration ou d'une correction qu'il soit écrit par vous ou par un autre, pose toujours comme problème sa lisibilité et la compréhension de son déroulement. Essayer de modifier un programme de plus de 1000 lignes sans documentation adéquate, sans règles d'écriture, sans découpage suffisant des opérations (surtout s'il n'est pas de votre cru), devient vite un lourd travail. Pour une modification vous pourrez passer presque autant de temps que la conception même du programme. Donc une bonne maintenance se prépare dès la conception du projet. Test: Vérifier, avant l'écriture globale d'une application, son fonctionnement et avoir la preuve du bon déroulement du prototype permet, de réduire au minimum les corrections tardives, et donc, un gain de temps souvant significatif. Un programme automatisant ces opérations lourdes à gérer "manuellement", enlève toute objections quant à leur utilisation. En l'occurence, une base de connaissance, crée avec un système expert et représentant l'application, peut constituer le noyau d'un tel programme. Une structure se réduisant bien sous forme de succèsions de règles. Evidement le programme présenté ne repond pas dans l'absolu à ses problèmes, mais c'est un début de reponse. ______________________________Présentation de la Programmation Sans Pannes Dans les explications qui suivent je ne décrirais que les parties de la PSP utilisées par SAD, pour plus de détails procurez-vous les n° de la revue Micro-Systèmes de Juillet à Octobre 1987. La PSP dépasse la démarche structuraliste. Sa démarche est basée sur la notion d'objet. Elle définie "quelles choses fait-on ?" et non plus "pourquoi fait-on les choses ?". La démarche de l'analyse se fait en 3 points: * Dans un problème, il existe des objets soumis à des traitements. * En isolant et décomposant ces objets, on dégage la structure de l'algorithme. * Pour chaque objet dégager les traitements à effectuer sur l'objet, puis les conditions dans lesquelles ils sont effectués. Un programme = - instructions qui se suivent en séquence et qui ne contiennent aucun branchement ou rupture de séquence. - instructions rompant la séquence. 2 types : * Répétition ; c'est à dire le branchement ramène en arrière pour ré-exécuter certaines instructions autant de fois qu'il est nécessaire jusqu'à ce qu'une condition soit vérifiée. (WHILE <condition non vérifiée>...WEND) * Alternative ; c'est-à-dire pas de répétition et le branchement renvoie à une autre instruction. Dans ce cas, certaines instructions seront exécutées ou pas, selon que la condition associée soit vraie ou fausse. (IF <condition> THEN...ELSE...) Un programme peut être composé uniquement de ces 3 éléments. Ces éléments s'imbriquant et s'ajoutant selon les problèmes à résoudre. * En pratique et en BASIC ces structures se traduisent ainsi : (attention, c'est une vision simplifiée de la technique) Les noms d'objet servent comme nom des procédures qui les concernent, mais aussi aux variables logiques qui conditionnent leur fonctionnement. Séquence= Appel du sous-programme:-"GOSUB nom bloc d'instructions". Sous-programme:-"nom du bloc d'instructions:". -séquence d'instructions. -"RETURN" retour au programme appellant. Répétitive= Appel de la répétitive :"GOSUB nom de la répétitive". Répétitive:-"WHILE condition fausse". -"GOSUB bloc" ,appel à la séquence d'instructions à exécuter. -"WEND". Sous-programme:-"nom du bloc:". -séquence d'instructions et détermination de la condition. -"RETURN" retour au programme appellant. Alternative= Appel de l'alternative :"GOSUB nom de l'alternative". Alternative:-"GOSUB calcul de la condition de l'alternative". -"IF condition vraie" -"THEN GOSUB 1er traitement de l'alternative". -"ELSE GOSUB 2ième traitement de l'alternative" -"RETURN" retour au programme appellant. Sous-programme de calcul de la condition :-"calcul condition:". - séquence de calcul. -"RETURN". Sous-programmes des traitements :-"1er traitement". -séquence -"RETURN" -"2ième traitement". -séquence -"RETURN" Remarque : Cette façon de découper un programme peut sembler fastidueuse, mais elle permet de comprendre par couche le programme et de séparer chaque opération de manière lisible. La PSP est une méthode très complète, la partie abordée ici n'est que le morceau visible de l'iceberg. ____________________________________________________Présentation de SAD Le noyau de SAD est un système expert simplifié capable d'inférences arrière et avant. Ces inférences vous permettront une fois la base de règles constituée d'éplucher votre application : - de savoir pour un sous-programme quel sont ceux qu'il appelle. - de connaître pour un sous-programme par quel(s) autres sous-programme(s) il est appelé. Bref de monter ou descendre dans la structure de l'application. Le niveau 0 étant le niveau initial (celui de la 1ère règle), le niveau n la dernière décomposition d'un objet. Pour maintenir un code, ces possibilités accèlérent la compréhension du déroulement des séquences et donc permettent une intervention plus rapide. En plus de cette navigation, SAD génére le code source correspondant à la base de règles. Deux versions peuvent être générées : - une version pure, qui n'est que l'exacte traduction de la base de règles. - une version de test, qui incorpe le code nécessaire à la visualisation du déroulement logique du programme. La base de règles peut représenter qu'une partie d'une application. En sub-divisant ainsi votre travail, votre vision du projet en sera accrue. Dans l'idéal vous ne devrez plus faire appel à votre éditeur de texte classique. A chaque modification, c'est une règle que vous changerez (en oubliant pas de passer après par la génération pour executer le code). _______________________________________________________Fonctionnalités * Sur la base de règles: - ajout, suppréssion, modification, visualisation de règles. * Inférences: (1 condition = 1 sous-programme) - Arrière. En donnant la condition d'une règle, le programme vous donnera les règles succéssives qui appellent celle-ci. - Avant. En donnant la condition d'une règle, le programme vous donnera les conséquences succéssives quelle implique. * Les fichiers: (Vous devez donnez un nom à la base de règle. Celui-ci servira aussi comme nom du futur programme généré.) - Re-initialisation des tableaux contenant la base, chargement et sauvegarde de la base de règles. * Génération de code: 2 types de générations. 1/ Pur. Crée un code suivant strictement les règles saisies. 2/ Test. Rajoute le code nécessaire pour effectuer des tests sur le déroulement du programme. En l'executant vous pourrez vérifier son fonctionnement logique. * Règles d'écriture de la base de connaissances: (voir simultanément l'exemple plus loin) Il devra toujours exister une règle ayant la condition MAIN (n'importe-où dans la base). Celle-ci ayant pour conséquence(s) le programme principal. Une règle = le nom de la séquence en prémisse, les instructions ou les séquences appellées en conséquences. (Il faudra obligatoirement créer 1 ou 2 conséquence(s), si la prémisse est une alternative IF..THEN..(ELSE))). La génération s'effectue sur le disque courant. Règles d'écriture des règles. - si <condition> alors <consequence> alors ... 8 conséquences possibles. - Dans une répétitive, la Condition commence par TANT QUE puis le nom de l'objet. En Conséquence on indique le nom du bloc de séquences à executer (Pas de TANT QUE...). - Dans une alternative, La Condition commence par TEST puis le nom de l'objet. En Conséquence, le 1er traitement commence de préférence par le nom de l'objet et fini par OUI, l'éventuel 2ième fini par NON (Pas de TANT QUE en Conséquence). - si le début d'une Conséquence commence par le caractère "*", le programme considèrera la suite de la ligne comme du code BASIC à inclure directement, tel quel, dans le source généré. Cela remplace donc, un éditeur classique. (voir le chapitre EXEMPLE). Vous remarquerez qu'à chaque décomposition d'un objet il y a un appel de sous-programme (ou création d'une autre règle). Cette décomposition permet une grande lisibilté du listing source, et une compréhension par niveau, de l'application. Mais comme je l'ai déjà écrit, vous n'aurez plus besoin de lire un source brut. Vous pourrez passer par l'édition des règles pour gérer votre programme. Certains tests sur la validité logique de la base de règles ne sont pas inclus (d'autres fonctions simples sont aussi absentes (impréssion des résultats de tests, de la base de règles etc...)) (prochaine version de SAD). Alors faites attention à ce que vous saisissez, sinon le programme généré risque d'être qu'une sacrée salade ! __________________________________________________________Conclusion Ce programme est plus que perfectible. Pour améliorer son utilité il faut le reprogrammer dans un langage plus puissant, améliorer l'ergonomie, la rapidité, le mixer avec un éditeur de texte etc... J'accepterais favorablement toutes remarques. Hilly Eric 100, rue de L'Escalette 59420 MOUVAUX SAD peut être diffusé gratuitement par qui le voudra, en aucuns cas il peut en être fait une distribution ou un usage commercial sans mon autorisation. Le programme SAD reste ma propriété, ainsi que le nom. ______________________________________________________________Exemple Voici un exemple d'application. A vous de le terminer (je suis paresseux de naissance !. D'ailleur j'aime tout ce qui inclus le mot AUTOMATIQUE). --------------------------------------------------------------------------- Jeu RESEAU * Lieu : réseau bus,tramway, metro. Acteurs : un voyageur (le joueur). Ses adversaires (2 à 8) gérés par le programme. But : pour le joueur, à partir d'un point du réseau rejoindre une autre station en évitant les poursuivants. Pour le programme, poursuivre le joueur et tenter par l'un des pousuivants de "l'attrapper". Fin de partie, lorsque l'un des 2 buts est atteint. Gain de points : si le but du joueur est atteint et proportionnellement au nombre de chasseurs. Liste des objets. * Réseau de lignes. Chaque ligne est représentée par ses stations. Chaque station est numérotée. Pour les correspondances, il faut indiquer le n° de ligne et le n° de la station sur cette ligne. (c'est-à-dire: une même station peut avoir un n° différent selon la ligne). Procédure indépendante de création du fichier du réseau. Procédure de lecture du fichier dans le programme RESEAU. * Chasseurs. Détermination du nombre de chasseurs. Chaque chasseur se détermine par son n° d'ordre, sa ligne, son n° de station. Détermination du point d'origine de chacun. Mouvement automatique de chaque chasseur selon la position du joueur. Si la position d'un des chasseurs est égale à celle du joueur, c'est la fin de partie, le joueur a perdu. (Toute rencontre entre les acteurs se fait aux stations. Le test ne tient pas compte du sens de progrèssion des protagonistes et donc ne rend pas compte de la réalité. Il teste simplement le passage dans une station sur une ligne identique.) * Joueur. La position originelle du joueur se détermine de la même façon que celle des chasseurs. Détermination du point à atteindre pour gagner la partie. Mouvement sur le réseau selon les possibilités de changement de station. (Le joueur n'a connaissance de la position des poursuivants que lorsqu'ils se trouvent sur la même ligne.) Si la position en cours est celle du point à atteindre, alors le joueur a gagné et peut ajouter à son total x points calculés selon le nombre de chasseurs. Déroulement des séquences. (vision restrictive) INITIALISATION LECTURE du FICHIER du RESEAU DETERMINATION du NOMBRE D'ENNEMIS " des positions ennemis, et joueur TANT QUE que l'on joue à une PARTIE , effectuer: TANT QUE la PHASE PRINCIPALE de jeu est à effectuer, faire: Détermination des MouVemenTs des CHASSEURS Détermination du MouVemenT du JOUEUR TEST de POSSIBILITE de changer de ligne pour le joueur Si oui, AFFICHAGE des possibilités, CHOIX DU JOUEUR, TEST du CHOIX de changement de ligne Si oui, évaluation des paramétres de la nouvelle position Si non, paramétres de mouvement inchangés Si non, CHOIX du SENS de progrèssion sur la ligne en cours Mise A Jour des coordonnées du joueur TEST de FIN de la PRINCIPALE PHASE Si oui, fin de la PRINCIPALE PHASE du jeu FIN DE LA PHASE PRINCIPALE FIN DE LA PARTIE Liste des règles. Ces 13 règles ne répresentent que l'ossature du problème, completez vous-même, cela fera un excellent exercice d'initiation. Rappel : Ici les règles sont ordonnées pour faciliter votre lecture, mais elles peuvent dans n'importe quel ordre. SAD s'y retrouve du moment qu'il y a une structure logique qui les unies. Règle n° 1 MAIN INITIALISATION TANT QUE PARTIE Règle n° 2 INITIALISATION LECTURE FICHIER RESEAU NBR ENNEMIS POSITION ENNEMIS POSITION JOUEUR Règle n° 3 TANT QUE PARTIE PARTIE Règle n° 4 PARTIE TANT QUE PRINCIPALE PHASE Règle n° 5 TANT QUE PRINCIPALE PHASE PRINCIPALE PHASE Règle n° 6 PRINCIPALE PHASE MVT CHASSEURS MVT JOUEUR MAJ COORDONNEES JOUEUR CALCUL FIN PRINCIPALE PHASE Règle n° 7 MVT JOUEUR TEST POSSIBILITE Règle n° 8 TEST POSSIBILITE POSSIBILITE OUI POSSIBILITE NON Règle n° 9 POSSIBILITE OUI AFFICHAGE CHOIX DU JOUEUR TEST CHOIX Règle n° 10 POSSIBILITE NON CHOIX DU SENS Règle n° 11 TEST CHOIX CHOIX OUI Règle n° 12 (règle à créer meme si il n'y a pas de conséquence(s)) CHOIX OUI Règle n°13 AFFICHAGE *PRINT "Test code" Version test générée par l'option "Génération Test". Le code source est divisé en couche. Une fonction à un niveau (n) ne peut etre appelée que par un niveau inférieur, et ne peut appeler une fonction que de niveau supérieur. RESEAUTEST.BAS OUI=1 : NON=0 GOSUB MAIN END '--------------------------------------------------Niveau 9 CALCULCHOIX: PRINT " CHOIX est V ou F ?" K$="" WHILE K$="" K$=INKEY$ WEND CHOIX=NON IF K$="V" THEN CHOIX=OUI RETURN CHOIXOUI: PRINT " -Exécution de CHOIX OUI" RETURN '--------------------------------------------------Niveau 8 AFFICHAGE: PRINT " -Exécution de AFFICHAGE" PRINT "TEST CODE" RETURN CHOIXDUJOUEUR: PRINT " -Exécution de CHOIX DU JOUEUR" RETURN TESTCHOIX: GOSUB CALCULCHOIX IF CHOIX=OUI THEN GOSUB CHOIXOUI RETURN CHOIXDUSENS: PRINT " -Exécution de CHOIX DU SENS" RETURN '--------------------------------------------------Niveau 7 CALCULPOSSIBILITE: PRINT " POSSIBILITE est V ou F ?" K$="" WHILE K$="" K$=INKEY$ WEND POSSIBILITE=NON IF K$="V" THEN POSSIBILITE=OUI RETURN POSSIBILITEOUI: PRINT " -Exécution de POSSIBILITE OUI" GOSUB AFFICHAGE GOSUB CHOIXDUJOUEUR GOSUB TESTCHOIX RETURN POSSIBILITENON: PRINT " -Exécution de POSSIBILITE NON" GOSUB CHOIXDUSENS RETURN '--------------------------------------------------Niveau 6 TESTPOSSIBILITE: GOSUB CALCULPOSSIBILITE IF POSSIBILITE=OUI THEN GOSUB POSSIBILITEOUI ELSE GOSUB POSSIBILITENON RETURN '--------------------------------------------------Niveau 5 MVTCHASSEURS: PRINT " -Exécution de MVT CHASSEURS" RETURN MVTJOUEUR: PRINT " -Exécution de MVT JOUEUR" GOSUB TESTPOSSIBILITE RETURN MAJCOORDONNEESJOUEUR: PRINT " -Exécution de MAJ COORDONNEES JOUEUR" RETURN CALCULFINPRINCIPALEPHASE: PRINT " -Exécution de CALCUL FIN PRINCIPALE PHASE" RETURN '--------------------------------------------------Niveau 4 PRINCIPALEPHASE: PRINT " -Exécution de PRINCIPALE PHASE" GOSUB MVTCHASSEURS GOSUB MVTJOUEUR GOSUB MAJCOORDONNEESJOUEUR GOSUB CALCULFINPRINCIPALEPHASE RETURN '--------------------------------------------------Niveau 3 TANTQUEPRINCIPALEPHASE: PRINCIPALEPHASE=NON WHILE PRINCIPALEPHASE=NON GOSUB PRINCIPALEPHASE PRINT " PRINCIPALEPHASE est V ou F ?" K$="" WHILE K$="" K$=INKEY$ WEND IF K$="V" THEN PRINCIPALEPHASE=OUI WEND RETURN '--------------------------------------------------Niveau 2 LECTUREFICHIERRESEAU: PRINT " -Exécution de LECTURE FICHIER RESEAU" RETURN NBRENNEMIS: PRINT " -Exécution de NBR ENNEMIS" RETURN POSITIONENNEMIS: PRINT " -Exécution de POSITION ENNEMIS" RETURN POSITIONJOUEUR: PRINT " -Exécution de POSITION JOUEUR" RETURN PARTIE: PRINT " -Exécution de PARTIE" GOSUB TANTQUEPRINCIPALEPHASE RETURN '--------------------------------------------------Niveau 1 INITIALISATION: PRINT " -Exécution de INITIALISATION" GOSUB LECTUREFICHIERRESEAU GOSUB NBRENNEMIS GOSUB POSITIONENNEMIS GOSUB POSITIONJOUEUR RETURN TANTQUEPARTIE: PARTIE=NON WHILE PARTIE=NON GOSUB PARTIE PRINT " PARTIE est V ou F ?" K$="" WHILE K$="" K$=INKEY$ WEND IF K$="V" THEN PARTIE=OUI WEND RETURN '--------------------------------------------------Niveau 0 MAIN: PRINT "-Exécution de MAIN" GOSUB INITIALISATION GOSUB TANTQUEPARTIE RETURN Version de RESEAU obtenue par la génération pure. OUI=1 : NON=0 GOSUB MAIN END '--------------------------------------------------Niveau 9 CALCULCHOIX: RETURN CHOIXOUI: RETURN '--------------------------------------------------Niveau 8 AFFICHAGE: PRINT "TEST CODE" RETURN CHOIXDUJOUEUR: RETURN TESTCHOIX: GOSUB CALCULCHOIX IF CHOIX=OUI THEN GOSUB CHOIXOUI RETURN CHOIXDUSENS: RETURN '--------------------------------------------------Niveau 7 CALCULPOSSIBILITE: RETURN POSSIBILITEOUI: GOSUB AFFICHAGE GOSUB CHOIXDUJOUEUR GOSUB TESTCHOIX RETURN POSSIBILITENON: GOSUB CHOIXDUSENS RETURN '--------------------------------------------------Niveau 6 TESTPOSSIBILITE: GOSUB CALCULPOSSIBILITE IF POSSIBILITE=OUI THEN GOSUB POSSIBILITEOUI ELSE GOSUB POSSIBILITENON RETURN '--------------------------------------------------Niveau 5 MVTCHASSEURS: RETURN MVTJOUEUR: GOSUB TESTPOSSIBILITE RETURN MAJCOORDONNEESJOUEUR: RETURN CALCULFINPRINCIPALEPHASE: RETURN '--------------------------------------------------Niveau 4 PRINCIPALEPHASE: GOSUB MVTCHASSEURS GOSUB MVTJOUEUR GOSUB MAJCOORDONNEESJOUEUR GOSUB CALCULFINPRINCIPALEPHASE RETURN '--------------------------------------------------Niveau 3 TANTQUEPRINCIPALEPHASE: PRINCIPALEPHASE=NON WHILE PRINCIPALEPHASE=NON GOSUB PRINCIPALEPHASE WEND RETURN '--------------------------------------------------Niveau 2 LECTUREFICHIERRESEAU: RETURN NBRENNEMIS: RETURN POSITIONENNEMIS: RETURN POSITIONJOUEUR: RETURN PARTIE: GOSUB TANTQUEPRINCIPALEPHASE RETURN '--------------------------------------------------Niveau 1 INITIALISATION: GOSUB LECTUREFICHIERRESEAU GOSUB NBRENNEMIS GOSUB POSITIONENNEMIS GOSUB POSITIONJOUEUR RETURN TANTQUEPARTIE: PARTIE=NON WHILE PARTIE=NON GOSUB PARTIE WEND RETURN '--------------------------------------------------Niveau 0 MAIN: GOSUB INITIALISATION GOSUB TANTQUEPARTIE RETURN